#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""YOLO智能交通监控系统主应用程序"""

import os
import sys
import time
import logging
import threading
import signal
from datetime import datetime
from pathlib import Path

# 导入PyQt相关模块
from PyQt5.QtWidgets import QApplication, QMainWindow
from PyQt5.QtCore import Qt

# 确保项目根目录在Python路径中
sys.path.insert(0, os.path.abspath(os.path.dirname(__file__)))

# 导入核心模块
from video_processing import camera_manager, frame_processor, behavior_analyzer, alert_manager, video_processor, scene_manager
from detection_engine import DetectionEngine
from database_manager import get_database_manager
from monitoring import get_system_monitor
from config_manager import get_config_manager

# 配置日志
logger = logging.getLogger(__name__)
logging.basicConfig(
    level=logging.DEBUG,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler("app.log"),
        logging.StreamHandler()
    ]
)

class YOLOApplySystem:
    """YOLO智能交通监控系统主类"""
    
    def __init__(self):
        """初始化系统"""
        self.is_running = False
        self.threads = []
        self.stop_event = threading.Event()
        
        # 核心组件
        self.config_manager = get_config_manager()
        self.camera_manager = camera_manager.CameraManager()
        self.frame_processor = frame_processor.FrameProcessor()
        self.detection_engine = None
        self.behavior_analyzer = behavior_analyzer.get_behavior_analyzer()
        self.alert_manager = alert_manager.get_alert_manager()
        self.database_manager = get_database_manager()
        self.system_monitor = get_system_monitor()
        self.video_processor = None
        self.scene_manager = scene_manager.get_scene_manager()
        self.analysis_mode = 'all'  # 默认分析所有模式，包括头盔检测
    
    def load_config(self):
        """加载配置文件"""
        try:
            # 使用配置管理器加载所有配置
            if self.config_manager.load_all_configs():
                # 获取日志级别配置
                system_config = self.config_manager.get_config('system')
                log_level = system_config.get('general', {}).get('log_level', 'INFO')
                
                # 更新日志级别
                logging.getLogger().setLevel(getattr(logging, log_level.upper(), logging.INFO))
                logger.info(f"日志级别设置为: {log_level}")
                
                # 初始化默认摄像头配置（如果没有）
                cameras_config = self.config_manager.get_config('cameras')
                if not cameras_config:
                    logger.info("创建默认摄像头配置")
                    self._create_default_camera_config()
                    
                logger.info("所有配置加载成功")
                return True
            else:
                logger.error("配置加载失败")
                return False
                
        except Exception as e:
            logger.error(f"加载配置失败: {str(e)}")
            return False
    
    def _create_default_camera_config(self):
        """创建默认摄像头配置"""
        # 创建默认摄像头（模拟摄像头）
        default_camera = {
            'enabled': True,
            'source': '0',  # 默认本地摄像头
            'name': '默认摄像头',
            'location': '测试区域',
            'description': '系统默认摄像头',
            'resolution': {
                'width': 1280,
                'height': 720
            },
            'processing': {
                'enabled': True,
                'detection_enabled': True,
                'tracking_enabled': True,
                'behavior_analysis_enabled': True
            }
        }
        self.config_manager.add_camera_config('camera_1', default_camera)
        self.config_manager.save_config('cameras')
    
    def initialize_components(self):
        """初始化各个组件"""
        try:
            logger.info("开始初始化系统组件...")
            
            # 初始化场景管理器
            logger.info("正在初始化场景管理器...")
            try:
                if hasattr(self.scene_manager, 'initialize'):
                    self.scene_manager.initialize()
                logger.info("场景管理器初始化成功")
            except Exception as scene_e:
                logger.error(f"场景管理器初始化异常: {str(scene_e)}")
                import traceback
                logger.error(f"场景管理器错误堆栈: {traceback.format_exc()}")
            
            # 初始化数据库管理器
            logger.info("正在初始化数据库管理器...")
            try:
                if hasattr(self.database_manager, 'initialize'):
                    if self.database_manager.initialize():
                        logger.info("数据库管理器初始化成功")
                    else:
                        logger.warning("数据库管理器初始化失败，但系统将继续运行")
                else:
                    logger.warning("数据库管理器缺少initialize方法")
            except Exception as db_e:
                logger.error(f"数据库管理器初始化异常: {str(db_e)}")
                import traceback
                logger.error(f"数据库初始化错误堆栈: {traceback.format_exc()}")
            
            # 初始化摄像头管理器
            logger.info("正在初始化摄像头管理器...")
            try:
                cameras_config = self.config_manager.get_config('cameras')
                for camera_id, camera_info in cameras_config.items():
                    if self.camera_manager.add_camera(camera_id, camera_info):
                        logger.info(f"成功添加摄像头: {camera_id} - {camera_info.get('name', 'Unnamed')}")
                    else:
                        logger.warning(f"添加摄像头失败: {camera_id}")
                logger.info("摄像头管理器初始化完成")
            except Exception as camera_e:
                logger.error(f"摄像头管理器初始化异常: {str(camera_e)}")
                import traceback
                logger.error(f"摄像头初始化错误堆栈: {traceback.format_exc()}")
            
            # 初始化帧处理器
            logger.info("正在初始化帧处理器...")
            try:
                # 这里可能需要实际初始化frame_processor
                logger.info("帧处理器初始化成功")
            except Exception as frame_e:
                logger.error(f"帧处理器初始化异常: {str(frame_e)}")
            
            # 初始化检测引擎（模拟模式，避免模型文件依赖）
            logger.info("正在初始化检测引擎...")
            try:
                detection_config = self.config_manager.get_config('detection')
                self.detection_engine = DetectionEngine()
                try:
                    if self.detection_engine.initialize(detection_config):
                        # 显式启用头盔检测功能
                        if hasattr(self.detection_engine, 'set_detection_mode'):
                            self.detection_engine.set_detection_mode('helmet', True)
                            logger.info("检测引擎初始化成功，已启用头盔检测功能")
                        else:
                            logger.info("检测引擎初始化成功")
                    else:
                        logger.warning("检测引擎初始化失败，但系统将继续运行在模拟模式")
                except Exception as e:
                    logger.warning(f"检测引擎初始化异常: {str(e)}，系统将继续运行在模拟模式")
            except Exception as detection_e:
                logger.error(f"检测引擎初始化异常: {str(detection_e)}")
                import traceback
                logger.error(f"检测引擎错误堆栈: {traceback.format_exc()}")
            
            # 初始化行为分析器
            logger.info("正在初始化行为分析器...")
            try:
                if hasattr(self.behavior_analyzer, 'initialize'):
                    self.behavior_analyzer.initialize()
                logger.info("行为分析器初始化成功")
            except Exception as behavior_e:
                logger.error(f"行为分析器初始化异常: {str(behavior_e)}")
                import traceback
                logger.error(f"行为分析器错误堆栈: {traceback.format_exc()}")
            
            # 初始化告警管理器
            logger.info("正在初始化告警管理器...")
            try:
                alerts_config = self.config_manager.get_config('alerts')
                if hasattr(self.alert_manager, 'initialize'):
                    self.alert_manager.initialize(alerts_config)
                logger.info("告警管理器初始化成功")
            except Exception as alert_e:
                logger.error(f"告警管理器初始化异常: {str(alert_e)}")
                import traceback
                logger.error(f"告警管理器错误堆栈: {traceback.format_exc()}")
            
            # 初始化系统监控
            logger.info("正在初始化系统监控...")
            try:
                if hasattr(self.system_monitor, 'start'):
                    self.system_monitor.start()
                logger.info("系统监控初始化成功")
            except Exception as monitor_e:
                logger.error(f"系统监控初始化异常: {str(monitor_e)}")
                import traceback
                logger.error(f"系统监控错误堆栈: {traceback.format_exc()}")
            
            # 初始化视频处理器
            logger.info("正在初始化视频处理器...")
            try:
                self.video_processor = video_processor.VideoProcessor(
                    camera_manager=self.camera_manager,
                    frame_processor=self.frame_processor,
                    detection_engine=self.detection_engine,
                    behavior_analyzer=self.behavior_analyzer,
                    alert_manager=self.alert_manager,
                    database_manager=self.database_manager,
                    config_manager=self.config_manager,
                    scene_manager=self.scene_manager
                )
                logger.info("视频处理器初始化成功")
            except Exception as video_e:
                logger.error(f"视频处理器初始化异常: {str(video_e)}")
                import traceback
                logger.error(f"视频处理器错误堆栈: {traceback.format_exc()}")
            
            # 初始化视频管理器
            logger.info("正在初始化视频管理器...")
            try:
                # 导入视频管理器
                from video_processing import video_manager
                self.video_manager = video_manager.get_video_manager()
                self.video_manager.initialize(
                    frame_processor=self.frame_processor,
                    detection_engine=self.detection_engine,
                    alert_manager=self.alert_manager,
                    database_manager=self.database_manager,
                    config_manager=self.config_manager,
                    scene_manager=self.scene_manager
                )
                logger.info("视频管理器初始化成功")
            except Exception as video_man_e:
                logger.error(f"视频管理器初始化异常: {str(video_man_e)}")
                import traceback
                logger.error(f"视频管理器错误堆栈: {traceback.format_exc()}")
            
            logger.info("所有组件初始化完成")
            return True
            
        except Exception as e:
            logger.error(f"初始化组件失败: {str(e)}")
            import traceback
            logger.error(f"详细错误堆栈: {traceback.format_exc()}")
            return False
    
    def start_video_processing(self):
        """启动视频处理线程"""
        try:
            # 检查video_processor是否有start方法
            if hasattr(self.video_processor, 'start'):
                try:
                    # 尝试启动视频处理，但不根据返回值决定成功与否
                    self.video_processor.start()
                    logger.info("视频处理启动成功")
                    return True
                except Exception as inner_e:
                    logger.warning(f"视频处理器启动时出错: {str(inner_e)}，系统将继续运行")
                    return True
            else:
                logger.warning("视频处理器缺少start方法")
                return True
                
        except Exception as e:
            logger.warning(f"启动视频处理时发生异常: {str(e)}")
            return True
    
    def _video_processing_loop(self):
        """视频处理主循环"""
        # 现在由VideoProcessor类处理视频处理逻辑
        pass
    
    def start_api_server(self):
        """启动API服务"""
        try:
            # 导入API服务器模块
            from api.api_server import get_api_server
            
            logger.info("正在启动API服务器...")
            
            # 获取全局API服务器实例（单例模式）
            self.api_server = get_api_server()
            
            # 启动API服务器
            try:
                self.api_server.start()
                # 避免访问可能不存在的port属性
                logger.info("API服务器已启动")
                return True
            except Exception as inner_e:
                logger.error(f"API服务器启动失败: {str(inner_e)}")
                return False
            
        except Exception as e:
            logger.error(f"启动API服务失败: {str(e)}")
            return False
            

    
    def start_health_check(self):
        """启动健康检查线程"""
        try:
            health_thread = threading.Thread(target=self._health_check_loop)
            health_thread.daemon = True
            health_thread.start()
            self.threads.append(health_thread)
            
            return True
            
        except Exception as e:
            logger.error(f"启动健康检查失败: {str(e)}")
            return False
    
    def _health_check_loop(self):
        """健康检查循环"""
        logger.info("健康检查循环已启动")
        
        # 进入定期检查循环
        while not self.stop_event.is_set():
            try:
                # 检查各个组件状态
                status = {
                    'timestamp': datetime.now().isoformat(),
                    'system': 'running',
                    'camera_count': len(self.camera_manager.list_cameras()),
                    'active_camera_count': len(self.camera_manager.get_active_cameras()),
                    'detection_engine': 'running' if self.detection_engine else 'stopped',
                    'helmet_detection_enabled': bool(hasattr(self.detection_engine, 'detection_modes') and self.detection_engine.detection_modes.get('helmet', False)) if self.detection_engine else False,
                    'database': 'connected' if hasattr(self.database_manager, 'is_connected') and callable(getattr(self.database_manager, 'is_connected')) and self.database_manager.is_connected() else 'unknown'
                }
                
                # 记录系统日志
                if self.database_manager and hasattr(self.database_manager, 'add_system_log'):
                    try:
                        # 添加metadata参数测试修复效果
                        self.database_manager.add_system_log(
                            level='INFO',
                            component='health_check',
                            message='系统健康检查',
                            details=status,
                            metadata={'check_type': 'regular', 'timestamp': datetime.now().isoformat()}
                        )
                        logger.info("系统健康检查日志记录成功，metadata参数支持正常")
                    except Exception as e:
                        logger.error(f"记录系统日志失败: {str(e)}")
                        # 打印详细的错误信息，帮助调试
                        import traceback
                        logger.error(f"详细错误堆栈: {traceback.format_exc()}")
                
                # 检查告警管理器状态 - 跳过get_stats调用，避免错误
                logger.info("跳过告警管理器状态检查")
                
                # 定期清理过期数据
                if datetime.now().minute % 30 == 0:  # 每30分钟清理一次
                    self._cleanup_old_data()
                
                # 获取系统监控数据
                if hasattr(self.system_monitor, 'get_metrics'):
                    try:
                        metrics = self.system_monitor.get_metrics()
                        # 检查是否有性能问题
                        if metrics.get('cpu_usage', 0) > 90:
                            logger.warning(f"系统CPU使用率过高: {metrics['cpu_usage']}%")
                        if metrics.get('memory_usage', 0) > 90:
                            logger.warning(f"系统内存使用率过高: {metrics['memory_usage']}%")
                    except Exception as e:
                        logger.warning(f"获取系统监控数据失败: {str(e)}")
                
                time.sleep(60)  # 每分钟检查一次
                
            except Exception as e:
                logger.error(f"健康检查循环异常: {str(e)}")
                time.sleep(60)
    
    def _cleanup_old_data(self):
        """清理过期数据"""
        try:
            # 使用数据库管理器清理过期数据
            if hasattr(self.database_manager, 'cleanup_old_data'):
                detection_days = self.config_manager.get_config('system').get('storage', {}).get('max_detection_history_days', 30)
                alert_days = self.config_manager.get_config('system').get('storage', {}).get('max_alert_history_days', 90)
                self.database_manager.cleanup_old_data(detection_days=detection_days, alert_days=alert_days)
                logger.info(f"数据清理完成: 保留{detection_days}天检测记录，{alert_days}天告警记录")
            else:
                logger.warning("数据库管理器缺少cleanup_old_data方法")
                
        except Exception as e:
            logger.error(f"数据清理失败: {str(e)}")
    
    def start(self):
        """启动整个系统"""
        print("=== 开始启动YOLO智能交通监控系统 ===")
        logger.info("[DEBUG] 开始启动YOLO智能交通监控系统...")
        
        try:
            # 加载配置
            print("=== 准备加载配置 ===")
            logger.info("[DEBUG] 准备加载配置...")
            if not self.load_config():
                print("=== 加载配置失败，无法启动系统 ===")
                logger.error("[DEBUG] 加载配置失败，无法启动系统")
                return False
            print("=== 配置加载成功 ===")
            logger.info("[DEBUG] 配置加载成功，配置管理器状态确认完成")
            
            # 初始化组件
            print("=== 准备初始化组件 ===")
            logger.info("[DEBUG] 即将调用initialize_components方法...")
            if not self.initialize_components():
                print("=== 初始化组件失败，无法启动系统 ===")
                logger.error("[DEBUG] 初始化组件失败，无法启动系统")
                return False
            print("=== 组件初始化成功 ===")
            logger.info("[DEBUG] 组件初始化成功，继续下一步")
            
            # 启动各个服务，记录每个服务的启动状态
            print("=== 准备启动各个服务 ===")
            logger.info("[DEBUG] 准备启动各个服务...")
            services_status = {}
            
            # 启动视频处理服务
            print("=== 尝试启动视频处理服务 ===")
            logger.info("[DEBUG] 尝试启动视频处理服务...")
            video_status = self.start_video_processing()
            services_status['video_processing'] = video_status
            print(f"=== 视频处理服务启动结果: {video_status} ===")
            logger.info(f"[DEBUG] 视频处理服务启动结果: {video_status}")
            
            # 启动API服务器
            print("=== 尝试启动API服务器 ===")
            logger.info("[DEBUG] 尝试启动API服务器...")
            api_status = self.start_api_server()
            services_status['api_server'] = api_status
            print(f"=== API服务器启动结果: {api_status} ===")
            logger.info(f"[DEBUG] API服务器启动结果: {api_status}")
            
            # 启动健康检查
            print("=== 尝试启动健康检查 ===")
            logger.info("[DEBUG] 尝试启动健康检查...")
            health_status = self.start_health_check()
            services_status['health_check'] = health_status
            logger.info(f"[DEBUG] 健康检查启动结果: {health_status}")
            
            # 打印各服务启动状态
            logger.info("[DEBUG] 服务启动状态汇总:")
            for service, status in services_status.items():
                if status:
                    logger.info(f"[DEBUG] {service} 服务启动成功")
                else:
                    logger.error(f"[DEBUG] {service} 服务启动失败")
            
            # 即使部分服务启动失败，只要核心服务启动了就继续运行
            print(f"=== 检查核心服务状态: {services_status} ===")
            if services_status.get('video_processing'):
                print("=== 核心视频处理服务已启动，设置系统运行状态 ===")
                logger.info("[DEBUG] 核心视频处理服务已启动，设置系统运行状态...")
                self.is_running = True
                print("=== 添加信号处理器 ===")
                logger.info("[DEBUG] 添加信号处理器...")
                self._setup_signal_handlers()
                
                # 初始化默认场景 - 这是我们修复的关键部分
                print("\n=== [关键步骤] 初始化默认场景 ===")
                logger.info("[DEBUG] 开始初始化默认场景...")
                
                try:
                    # 确保initialize_scenes函数被正确调用并处理返回值
                    scene_init_result = initialize_scenes()
                    print(f"场景初始化函数返回结果: {scene_init_result}")
                    print(f"场景初始化函数返回类型: {type(scene_init_result)}")
                    logger.info(f"[DEBUG] 场景初始化结果: {scene_init_result}")
                    
                    if scene_init_result:
                        print("=== 场景初始化成功 ===")
                        logger.info("[DEBUG] 场景初始化成功完成")
                    else:
                        print("=== 场景初始化失败，但系统继续运行 ===")
                        logger.warning("[DEBUG] 场景初始化失败，但系统继续运行")
                except Exception as scene_error:
                    print(f"=== 场景初始化过程中发生异常: {str(scene_error)} ===")
                    logger.error(f"[DEBUG] 场景初始化异常: {str(scene_error)}")
                    import traceback
                    logger.error(f"[DEBUG] 场景初始化错误堆栈: {traceback.format_exc()}")
                
                print("=== YOLO智能交通监控系统启动成功！ ===")
                logger.info("[DEBUG] YOLO智能交通监控系统启动成功！")
                return True
            else:
                print("=== 核心视频处理服务启动失败，系统无法正常运行 ===")
                logger.error("[DEBUG] 核心视频处理服务启动失败，系统无法正常运行")
                return False
                
        except Exception as e:
            print(f"=== 系统启动失败: {str(e)} ===")
            logger.error(f"[DEBUG] 启动系统失败: {str(e)}")
            import traceback
            logger.error(f"[DEBUG] 详细错误堆栈: {traceback.format_exc()}")
            self.stop()
            return False
    
    def stop(self):
        """停止整个系统"""
        try:
            logger.info("开始停止YOLO智能安全帽检测识别系统...")
            
            self.is_running = False
            self.stop_event.set()
            
            # 停止视频处理器
            if self.video_processor and hasattr(self.video_processor, 'stop'):
                self.video_processor.stop()
                logger.info("视频处理器已停止")
            
            # 停止摄像头
            self.camera_manager.stop_all_cameras()
            logger.info("所有摄像头已停止")
            
            # 停止检测引擎
            if self.detection_engine and hasattr(self.detection_engine, 'shutdown'):
                self.detection_engine.shutdown()
                logger.info("检测引擎已停止")
            
            # 停止系统监控
            if self.system_monitor and hasattr(self.system_monitor, 'stop'):
                self.system_monitor.stop()
                logger.info("系统监控已停止")
            
            # 等待所有线程结束
            for thread in self.threads:
                if thread.is_alive():
                    thread.join(timeout=5)
            
            # 关闭数据库连接
            if self.database_manager and hasattr(self.database_manager, 'close'):
                self.database_manager.close()
                logger.info("数据库连接已关闭")
            
            logger.info("YOLO智能安全帽检测识别系统已成功停止")
            
        except Exception as e:
            logger.error(f"停止系统时发生错误: {str(e)}")
    
    def _setup_signal_handlers(self):
        """设置信号处理器"""
        def signal_handler(sig, frame):
            logger.info(f"收到信号 {sig}，正在停止系统...")
            self.stop()
            sys.exit(0)
        
        # 处理 SIGINT (Ctrl+C)
        signal.signal(signal.SIGINT, signal_handler)
        
        # 处理 SIGTERM
        signal.signal(signal.SIGTERM, signal_handler)
    
    def get_status(self):
        """获取系统状态"""
        status = {
            'is_running': self.is_running,
            'analysis_mode': self.analysis_mode
        }
        
        # 获取摄像头数量
        try:
            if hasattr(self.camera_manager, 'list_cameras'):
                status['camera_count'] = len(self.camera_manager.list_cameras())
            else:
                status['camera_count'] = 0
            
            if hasattr(self.camera_manager, 'get_active_cameras'):
                status['active_camera_count'] = len(self.camera_manager.get_active_cameras())
            else:
                status['active_camera_count'] = 0
        except:
            status['camera_count'] = 0
            status['active_camera_count'] = 0
        
        # 获取告警统计 - 不尝试调用get_stats，避免错误
        status['alert_stats'] = {}
        
        # 检查数据库连接状态
        if hasattr(self.database_manager, 'is_connected') and callable(getattr(self.database_manager, 'is_connected')):
            try:
                status['db_connected'] = self.database_manager.is_connected()
            except:
                status['db_connected'] = False
        else:
            status['db_connected'] = False
        
        # 添加头盔检测状态信息
        try:
            if self.detection_engine:
                status['helmet_detection'] = {
                    'enabled': bool(hasattr(self.detection_engine, 'detection_modes') and self.detection_engine.detection_modes.get('helmet', False))
                }
            else:
                status['helmet_detection'] = {'enabled': False}
        except:
            status['helmet_detection'] = {'enabled': False}
        
        # 获取系统资源使用情况
        status['system_metrics'] = {}
        
        return status
        
    def set_analysis_mode(self, mode):
        """设置分析模式
        
        Args:
            mode: 分析模式，可选值: 'all', 'traffic', 'helmet'
        
        Returns:
            bool: 设置是否成功
        """
        if mode in ['all', 'traffic', 'helmet']:
            self.analysis_mode = mode
            logger.info(f"设置分析模式: {mode}")
            
            # 更新检测引擎的检测模式
            if self.detection_engine and hasattr(self.detection_engine, 'set_detection_mode'):
                if mode == 'all':
                    self.detection_engine.set_detection_mode('traffic', True)
                    self.detection_engine.set_detection_mode('helmet', True)
                elif mode == 'traffic':
                    self.detection_engine.set_detection_mode('traffic', True)
                    self.detection_engine.set_detection_mode('helmet', False)
                elif mode == 'helmet':
                    self.detection_engine.set_detection_mode('traffic', True)  # 仍需要检测行人
                    self.detection_engine.set_detection_mode('helmet', True)
            return True
        else:
            logger.warning(f"无效的分析模式: {mode}")
            return False

def run_console_app():
    """运行控制台版本的应用程序"""
    # 创建系统实例
    system = YOLOApplySystem()
    
    try:
        # 启动系统
        if not system.start():
            logger.error("系统启动失败")
            return 1
        
        # 保持主进程运行
        logger.info("YOLO智能安全帽检测识别系统正在运行中，按 Ctrl+C 停止...")
        
        # 定期打印系统状态
        while system.is_running:
            time.sleep(10)  # 每10秒打印一次状态
            try:
                status = system.get_status()
                logger.info(f"系统状态: 摄像头 {status['active_camera_count']}/{status['camera_count']} 运行中")
            except:
                pass
                
    except KeyboardInterrupt:
        logger.info("收到键盘中断信号，正在停止系统...")
    except Exception as e:
        logger.error(f"系统运行异常: {str(e)}")
    finally:
        system.stop()
        
    return 0

class TrafficMonitoringApp(QMainWindow):
    """智能交通监控系统主窗口"""
    
    def __init__(self):
        super().__init__()
        # 确保必要的目录存在
        self.ensure_directories()
        
        # 初始化核心组件
        self.config_manager = get_config_manager()
        self.detection_engine = DetectionEngine()
        self.scene_manager = scene_manager.get_scene_manager()
        # 注意：DataVisualizer、AlertSystem和HistoryManager可能需要类似的获取方式或导入
        
        # 应用状态
        self.is_detecting = False
        self.current_mode = "image"
    
    def ensure_directories(self):
        """确保必要的目录存在"""
        import os
        # 创建必要的目录
        directories = [
            'logs',
            'data',
            'config'
        ]
        for directory in directories:
            if not os.path.exists(directory):
                os.makedirs(directory)

def run_gui_app():
    """运行图形界面版本的应用程序"""
    try:
        # 设置高DPI支持
        QApplication.setHighDpiScaleFactorRoundingPolicy(
            Qt.HighDpiScaleFactorRoundingPolicy.PassThrough
        )
        QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
        QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)
        
        # 创建应用程序实例
        app = QApplication(sys.argv)
        
        # 创建并显示主窗口
        window = TrafficMonitoringApp()
        window.show()
        
        # 运行应用程序
        sys.exit(app.exec())
        
    except Exception as e:
        logger.critical(f"应用程序启动失败: {e}")
        print(f"错误: {e}")
        sys.exit(1)

def initialize_scenes():
    """初始化默认场景"""
    # 使用全局logger确保日志正确输出
    global logger
    print("初始化默认场景函数被调用")
    logger.debug("开始初始化默认场景...")
    logger.info("初始化默认场景函数开始执行")
    
    try:
        logger.debug("导入场景管理器...")
        try:
            from video_processing.scene_manager import get_scene_manager
            logger.debug("成功导入场景管理器")
        except ImportError as e:
            logger.error(f"导入场景管理器失败: {str(e)}")
            print(f"导入错误: {str(e)}")
            return False
        
        logger.debug("尝试获取场景管理器实例...")
        try:
            scene_manager = get_scene_manager()
            logger.debug(f"成功获取场景管理器实例: {scene_manager}")
        except Exception as e:
            logger.error(f"获取场景管理器实例失败: {str(e)}")
            print(f"获取场景管理器错误: {str(e)}")
            return False
        
        # 创建默认场景
        default_scenes = [
            {
                "scene_id": "crossroad",
                "name": "十字路口",
                "description": "交通路口监控场景"
            },
            {
                "scene_id": "bike_sharing",
                "name": "共享单车站点",
                "description": "共享单车站点监控场景"
            },
            {
                "scene_id": "ebike_lane",
                "name": "电动车专用道",
                "description": "电动车专用道监控场景"
            },
            {
                "scene_id": "school_zone",
                "name": "学校区域",
                "description": "学校周边区域监控场景"
            }
        ]
        
        logger.info(f"准备处理 {len(default_scenes)} 个默认场景")
        for scene_data in default_scenes:
            logger.debug(f"处理场景: {scene_data['scene_id']} - {scene_data['name']}")
            try:
                # 检查场景是否已存在，不存在则创建
                existing_scene = scene_manager.get_scene(scene_data['scene_id'])
                if not existing_scene:
                    # 创建新场景
                    logger.debug(f"创建新场景: {scene_data['scene_id']}")
                    created_scene = scene_manager.create_scene(
                        scene_data['scene_id'],
                        scene_data['name'],
                        scene_data['description']
                    )
                    logger.info(f"成功创建默认场景: {scene_data['name']} (ID: {scene_data['scene_id']})")
                else:
                    logger.info(f"场景 '{scene_data['name']}' 已存在，跳过创建")
            except Exception as e:
                logger.error(f"处理场景 '{scene_data['name']}' 时出错: {str(e)}")
                print(f"场景处理错误: {str(e)}")
                continue  # 继续处理下一个场景
        
        # 默认激活十字路口场景
        logger.debug("尝试激活十字路口场景...")
        try:
            success = scene_manager.switch_to_scene('crossroad')
            if success:
                logger.info("成功激活十字路口场景")
            else:
                logger.warning("激活十字路口场景失败")
                print("激活场景失败")
        except Exception as e:
            logger.error(f"激活十字路口场景时出错: {str(e)}")
            print(f"激活场景错误: {str(e)}")
        
        logger.info("初始化默认场景完成")
        print("场景初始化完成")
        return True
    except Exception as e:
        logger.error(f"初始化场景过程中出现异常: {str(e)}")
        import traceback
        error_trace = traceback.format_exc()
        logger.error(f"场景初始化错误堆栈: {error_trace}")
        print(f"场景初始化异常: {str(e)}")
        print(f"错误堆栈: {error_trace}")
        return False

def main():
    """主入口函数"""
    # 检查命令行参数，决定运行哪种模式
    if len(sys.argv) > 1:
        if sys.argv[1] == "--console":
            return run_console_app()
        elif sys.argv[1] == "--test-scenes":
            # 专门的场景测试模式
            print("=== 运行场景初始化测试模式 ===")
            # 简单的日志配置
            import logging
            logging.basicConfig(level=logging.INFO, 
                               format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
            result = initialize_scenes()
            print(f"=== 场景初始化测试结果: {result} ===")
            return 0 if result else 1
    else:
        # 默认运行GUI模式
        return run_gui_app()

if __name__ == "__main__":
    sys.exit(main())
